package com.itheima.datastructure.array;

import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Consumer;
import java.util.stream.IntStream;

/**
 * @author tantao
 * @version 1.0
 * @description: DynamicArray01
 * @date 2025/8/5 14:45
 */
public class DynamicArray01 implements Iterable<Integer> {
    private int size = 0; //有效元素个数

    private int capacity = 8; //数组容量

    private int[] array = {};


    /**
     * 向最后位置[size]位置添加元素
     *
     * @param element element
     */
    public void addLast(int element) {
        add(size, element);
    }

    /**
     * 向指定位置插入元素
     *
     * @param index   index
     * @param element element
     */
    public void add(int index, int element) {
        checkAndGrow();
        if (index >= 0 && index < size) { //插入位置合法
            //将index位置的元素向后挪动一位 【数据移动】
            System.arraycopy(array, index, array, index + 1, size - index);
        }
        //插入元素
        array[index] = element;
        //元素个数加1
        size++;
    }


    /**
     * 检查并扩容
     */
    private void checkAndGrow() {
        //容量检查
        if (size == 0) { //懒加载的思想
            array = new int[capacity];
        } else if (size >= capacity) {
            //进行扩容, 1.5
            capacity += capacity >>> 1;
            //创建一个新的数组
            int[] newArray = new int[capacity];
            //将原来的元素复制给新的数组
            System.arraycopy(array, 0, newArray, 0, size);
            //新的array取代原来的array
            array = newArray;
        }
    }


    /**
     * 获取指定位置的元素
     *
     * @param index index
     * @return int
     */
    public int get(int index) {
        return array[index];
    }


    /**
     * 删除指定位置的元素
     *
     * @param index index
     * @return 删除的元素
     */
    public int remove(int index) { //[0,size)
        int remove = array[index];
        if (index < size - 1) { //删除的元素不是最后一个元素
            //元素向前移动 【数据移动】
            System.arraycopy(array, index + 1, array, index, size - index - 1);
        }
        size--;
        return remove;
    }


    /**
     * 遍历1
     */
    public void foreach(Consumer<Integer> consumer) {
        for (int i = 0; i < size - 1; i++) {
            consumer.accept(array[i]);
        }
    }


    /**
     * 迭代器
     *
     * @return Iterator
     */

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int index = 0;

            @Override
            public boolean hasNext() {
                return index < size;
            }

            @Override
            public Integer next() {
                return array[index++];
            }
        };
    }

    /**
     * stream
     *
     * @return IntStream
     */
    public IntStream stream() {
        return IntStream.of(Arrays.copyOfRange(array, 0, size));
    }
}
